---
title: "06-访问控制修饰符"
created: 2025-12-02
tags:
  - Java
---
# 访问控制修饰符

在 Java 中，**访问修饰符**用于控制类、字段、方法和构造函数的访问权限。通过使用访问修饰符，可以实现封装，保护数据，并控制不同部分之间的访问范围。Java
提供了四种主要的访问修饰符，它们分别控制不同范围的访问权限。

### **Java 中的四种访问修饰符：**

1. `public`：公共的
2. `protected`：受保护的
3. **默认（包级别，**`default`**）**：没有指定修饰符时，默认是包级别的访问权限
4. `private`：私有的

#### **访问修饰符的适用范围**

| **修饰符** | **当前类** | **同一包内** | **子类（不同包）** | **其他包** |
| --- | --- | --- | --- | --- |
| **public** | 是 | 是 | 是 | 是 |
| **protected** | 是 | 是 | 是 | 否 |
| **default** | 是 | 是 | 否 | 否 |
| **private** | 是 | 否 | 否 | 否 |

### **1.** `public` **访问修饰符**

- **含义**：`public` 关键字表示该成员可以被任何其他类访问，包括同一包内、不同包中的类。
- **适用场景**：适用于那些需要被外部广泛访问的类、字段、方法和构造函数。

#### **示例**：

```java
public class Animal {
    public String name;

    public void eat() {
        System.out.println(name + " eats food.");
    }
}
```

在上面的例子中，`name` 字段和 `eat()` 方法都被声明为 `public`，因此它们可以被任何类访问。

---

### **2.** `protected` **访问修饰符**

- **含义**：`protected` 关键字表示该成员可以被同一包中的类访问，也可以被子类访问（即使子类在不同包中）。但不允许其他包的非子类访问。
- **适用场景**：适用于那些需要在继承关系中共享的字段或方法，或者在同一包中共享的字段或方法。

#### **示例**：

```java
class Animal {
    protected String name;

    protected void eat() {
        System.out.println(name + " eats food.");
    }
}

class Dog extends Animal {
    public void display() {
        name = "Dog";
        eat();
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.display();  // 正常访问，输出 "Dog eats food."
    }
}
```

在上面的例子中，`name` 字段和 `eat()` 方法被声明为 `protected`，因此子类 `Dog` 可以访问并使用它们。

---

### **3. 默认（包级别，**`default`**）访问修饰符**

- **含义**：如果没有显式指定访问修饰符，那么默认的访问修饰符是包级别（`default`）。这种情况下，该成员只能在同一包内访问，其他包中的类无法访问。
- **适用场景**：适用于仅在同一包内使用的类、字段、方法或构造函数。适当使用可以隐藏实现细节，减少类之间的耦合。

#### **示例**：

```java
class Animal {
    String name;

    void eat() {
        System.out.println(name + " eats food.");
    }
}
```

在这个例子中，`name` 字段和 `eat()` 方法没有使用任何访问修饰符，因此它们是默认的包级别（`default`）访问权限，只能在同一包内访问。

---

### **4.** `private` **访问修饰符**

- **含义**：`private` 关键字表示该成员只能在定义它的类内部访问，外部无法直接访问。`private` 访问修饰符提供了最严格的封装控制，确保数据和方法不会被外部直接修改。
- **适用场景**：适用于内部实现细节，确保类的内部数据和方法不被外部直接访问，保护类的封装性。

#### **示例**：

```java
class Animal {
    private String name;

    private void eat() {
        System.out.println(name + " eats food.");
    }

    public void setName(String name) {
        this.name = name;
    }

    public void display() {
        eat(); // 只能在类内部访问
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.setName("Dog");
        animal.display();  // 调用类内的方法
        // animal.eat();   // 编译错误，无法访问私有方法
    }
}
```

在这个例子中，`name` 字段和 `eat()` 方法是 `private` 的，因此它们不能被外部类访问。为了修改 `name` 字段的值，我们提供了一个 `public` 的 `setName()` 方法。

---

### **总结：选择合适的访问修饰符**

- `public`：适用于需要被外部类广泛访问的成员，尽量避免过多使用，以免降低封装性。
- `protected`：适用于需要在继承关系中访问的成员，提供比 `public` 更严格的控制。
- **默认（包级别）**：适用于同一包内共享的成员，减少类之间的耦合，隐藏实现细节。
- `private`：适用于类的内部实现细节，确保数据和方法不被外部直接访问，是最严格的访问控制。

通过合理使用访问修饰符，Java 可以有效实现封装，保护类的内部数据和方法，同时提供合适的访问范围，增强程序的安全性和可维护性。


## 相关笔记

本篇是速记视角；更系统的"四类访问范围→使用场景→常见坑"讲解见 [[03-访问权限|访问权限]]。

---
⬅️ [[05-编译时多态和运行时多态|编译时多态和运行时多态]] 🏠 [[00-Java|00-Java]] ➡️ [[07-为什么Java不支持多重继承？|为什么 Java 不支持多重继承？]]